package org.Yiran.timetale_re.item.tool.screwdriver.core;

import com.google.common.collect.ImmutableMultimap;
import com.google.common.collect.Multimap;
import net.minecraft.ChatFormatting;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.screens.Screen;
import net.minecraft.network.chat.Component;
import net.minecraft.world.InteractionHand;
import net.minecraft.world.InteractionResult;
import net.minecraft.world.InteractionResultHolder;
import net.minecraft.world.entity.EquipmentSlot;
import net.minecraft.world.entity.ai.attributes.Attribute;
import net.minecraft.world.entity.ai.attributes.AttributeModifier;
import net.minecraft.world.entity.ai.attributes.Attributes;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.TooltipFlag;
import net.minecraft.world.item.context.UseOnContext;
import net.minecraft.world.item.enchantment.Enchantment;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraftforge.api.distmarker.Dist;
import net.minecraftforge.api.distmarker.OnlyIn;
import net.minecraftforge.common.TierSortingRegistry;
import org.Yiran.timetale_re.client.gui.ModuleSelectionScreen;
import org.Yiran.timetale_re.item.machine.base.EnergyStorageItem;
import org.Yiran.timetale_re.item.tool.screwdriver.CreativeScrewdriverItem;
import org.Yiran.timetale_re.item.tool.screwdriver.modules.*;
import org.Yiran.timetale_re.item.tool.screwdriver.modules.container.ToolModuleContainer;
import org.Yiran.timetale_re.item.tool.screwdriver.modules.enmu.ModuleCategory;
import org.Yiran.timetale_re.item.tool.screwdriver.modules.enmu.ModuleType;
import org.Yiran.timetale_re.item.tool.screwdriver.modules.items.function.RedstoneModuleItem;
import org.Yiran.timetale_re.item.tool.screwdriver.modules.items.function.RotationModuleItem;
import org.Yiran.timetale_re.item.tool.screwdriver.modules.type.AttackModule;
import org.Yiran.timetale_re.item.tool.screwdriver.modules.type.MiningModule;
import org.Yiran.timetale_re.util.ScrewdriverModuleUtils;
import org.Yiran.timetale_re.util.item.TooltipUtils;
import org.jetbrains.annotations.NotNull;

import javax.annotation.Nullable;
import java.util.List;
import java.util.Optional;
import java.util.UUID;

/**
 * 起子工具基类
 * <p>
 * 该类是所有起子工具的抽象基类，继承自EnergyStorageItem。
 * 起子主要用于拧螺丝等精密操作。
 * 该类定义了起子的基本行为。
 * </p>
 */
public abstract class ScrewdriverItem extends EnergyStorageItem {

    // ==============================
    // 常量定义
    // ==============================

    private static final UUID ATTACK_DAMAGE_MODIFIER = UUID.fromString("CB3F55D3-645C-4F38-A497-9C13A33DB5CF");

    // ==============================
    // 构造方法
    // ==============================

    /**
     * 起子构造函数
     * <p>
     * 创建一个新的起子实例，设置其物品属性。
     * </p>
     *
     * @param capacity 电池容量
     * @param maxReceive 最大接收速率
     * @param maxExtract 最大提取速率
     * @param properties 物品属性
     * @param tierName 电池等级名称
     */
    public ScrewdriverItem(int capacity, int maxReceive, int maxExtract, Properties properties, String tierName) {
        super(capacity, maxReceive, maxExtract, properties, tierName);
    }

    // ==============================
    // 抽象方法
    // ==============================

    /**
     * 获取最大模块数量
     *
     * @return 最大模块数量
     */
    public abstract int getMaxModules();

    /**
     * 创建模块容器
     *
     * @return 模块容器
     */
    public ToolModuleContainer createModuleContainer() {
        // 确保最大模块数不为负数
        return new ToolModuleContainer(Math.max(0, getMaxModules()));
    }

    /**
     * 根据物品堆栈创建模块容器
     * <p>
     * 子类可以重写此方法以根据物品堆栈的属性创建不同大小的模块容器
     * </p>
     *
     * @param stack 物品堆栈
     * @return 模块容器
     */
    public ToolModuleContainer createModuleContainer(ItemStack stack) {
        // 检查物品堆栈是否有效
        if (stack == null) {
            return createModuleContainer();
        }
        return createModuleContainer();
    }

    // ==============================
    // 模块安装限制方法
    // ==============================
    
    /**
     * 检查模块是否可以安装到指定的起子上
     * <p>
     * 根据起子等级限制可安装的模块类型和数量
     * </p>
     *
     * @param screwdriverStack 起子物品栈
     * @param moduleItem       模块物品
     * @return 是否可以安装
     */
    private boolean canInstallModule(ItemStack screwdriverStack, ScrewdriverModuleItem moduleItem) {
        // 创造等级起子无法安装模块
        if (screwdriverStack.getItem() instanceof CreativeScrewdriverItem) {
            return false;
        }
        
        // 所有起子都需要检查安装限制
        return checkScrewdriverLevelRestrictions(screwdriverStack, moduleItem);
    }
    
    /**
     * 根据起子等级检查模块安装限制
     * <p>
     * 不同等级的起子对可安装的模块类型和数量有不同的限制
     * </p>
     *
     * @param screwdriverStack 起子物品栈
     * @param moduleItem       模块物品
     * @return 是否可以安装
     */
    private boolean checkScrewdriverLevelRestrictions(ItemStack screwdriverStack, ScrewdriverModuleItem moduleItem) {
        ScrewdriverModuleItem.ModuleLevel moduleLevel = moduleItem.getModuleLevel();
        
        // 创建临时容器检查已安装的模块
        ToolModuleContainer container = createModuleContainer(screwdriverStack);
        container.loadFromItemStack(screwdriverStack);
        
        // 根据起子类型判断等级限制
        if (screwdriverStack.getItem() instanceof org.Yiran.timetale_re.item.tool.screwdriver.BasicScrewdriverItem) {
            return canInstallModuleOnBasicScrewdriver(container, moduleLevel);
        } else if (screwdriverStack.getItem() instanceof org.Yiran.timetale_re.item.tool.screwdriver.ImprovedScrewdriverItem) {
            return canInstallModuleOnImprovedScrewdriver(container, moduleLevel);
        } else if (screwdriverStack.getItem() instanceof org.Yiran.timetale_re.item.tool.screwdriver.EliteScrewdriverItem) {
            return canInstallModuleOnEliteScrewdriver(container, moduleLevel);
        } else {
            // 专业等级和创造等级起子没有限制
            return true;
        }
    }
    
    /**
     * 检查模块是否可以安装到基础等级起子上
     * <p>
     * 基础等级起子最多支持1个中级模块加一个基础模块，不能安装高级模块
     * </p>
     *
     * @param container        模块容器
     * @param moduleLevel      模块等级
     * @return 是否可以安装
     */
    private boolean canInstallModuleOnBasicScrewdriver(ToolModuleContainer container, 
                                                       ScrewdriverModuleItem.ModuleLevel moduleLevel) {
        // 基础起子不能安装高级模块
        if (moduleLevel == ScrewdriverModuleItem.ModuleLevel.ELITE) {
            return false;
        }
        
        // 最多支持1个中级模块加一个基础模块
        if (moduleLevel == ScrewdriverModuleItem.ModuleLevel.ADVANCED) {
            // 检查是否已经有一个中级模块
            long advancedCount = countModulesByLevel(container, ScrewdriverModuleItem.ModuleLevel.ADVANCED);
            return advancedCount < 1; // 最多1个中级模块
        }
        return true; // 基础模块无限制
    }
    
    /**
     * 检查模块是否可以安装到改良等级起子上
     * <p>
     * 改良等级起子最多支持1个高级模块，其余任意
     * </p>
     *
     * @param container        模块容器
     * @param moduleLevel      模块等级
     * @return 是否可以安装
     */
    private boolean canInstallModuleOnImprovedScrewdriver(ToolModuleContainer container,
                                                          ScrewdriverModuleItem.ModuleLevel moduleLevel) {
        // 最多支持1个高级模块，其余任意
        if (moduleLevel == ScrewdriverModuleItem.ModuleLevel.ELITE) {
            // 检查是否已经有一个高级模块
            long eliteCount = countModulesByLevel(container, ScrewdriverModuleItem.ModuleLevel.ELITE);
            return eliteCount < 1; // 最多1个高级模块
        }
        return true; // 中级及以下模块无限制
    }
    
    /**
     * 检查模块是否可以安装到精英等级起子上
     * <p>
     * 精英等级起子最多支持3个高级模块，其余任意
     * </p>
     *
     * @param container        模块容器
     * @param moduleLevel      模块等级
     * @return 是否可以安装
     */
    private boolean canInstallModuleOnEliteScrewdriver(ToolModuleContainer container,
                                                       ScrewdriverModuleItem.ModuleLevel moduleLevel) {
        // 最多支持3个高级模块，其余任意
        if (moduleLevel == ScrewdriverModuleItem.ModuleLevel.ELITE) {
            // 检查是否已经有3个高级模块
            long eliteCount = countModulesByLevel(container, ScrewdriverModuleItem.ModuleLevel.ELITE);
            return eliteCount < 3; // 最多3个高级模块
        }
        return true; // 中级及以下模块无限制
    }
    
    /**
     * 统计指定等级模块的数量
     * <p>
     * 在模块容器中统计指定等级的模块数量
     * </p>
     *
     * @param container        模块容器
     * @param targetLevel      目标模块等级
     * @return 指定等级模块的数量
     */
    private long countModulesByLevel(ToolModuleContainer container,
                                     ScrewdriverModuleItem.ModuleLevel targetLevel) {
        return container.getModules().stream()
            .filter(m -> m instanceof ScrewdriverModuleItem)
            .map(m -> (ScrewdriverModuleItem) m)
            .filter(m -> m.getModuleLevel() == targetLevel)
            .count();
    }

    // ==============================
    // 附魔限制方法
    // ==============================

    /**
     * 判断是否可以在附魔台应用指定附魔
     * <p>
     * 重写父类方法，完全禁止起子的任何附魔。
     * </p>
     *
     * @param stack       起子物品栈
     * @param enchantment 待应用的附魔
     * @return 总是返回false，禁止所有附魔
     */
    @Override
    public boolean canApplyAtEnchantingTable(ItemStack stack, Enchantment enchantment) {
        // 禁止所有附魔
        return false;
    }

    /**
     * 获取物品的附魔价值
     * <p>
     * 重写父类方法，将附魔价值设为0以完全禁止附魔。
     * </p>
     *
     * @param stack 物品堆栈
     * @return 附魔价值，总是返回0
     */
    @Override
    public int getEnchantmentValue(ItemStack stack) {
        // 返回0以完全禁用附魔
        return 0;
    }

    /**
     * 判断附魔书是否可以附魔该物品
     * <p>
     * 重写父类方法，完全禁止通过铁砧附魔。
     * </p>
     *
     * @param stack 起子物品栈
     * @param book  附魔书
     * @return 总是返回false，禁止通过铁砧附魔
     */
    @Override
    public boolean isBookEnchantable(ItemStack stack, ItemStack book) {
        // 禁止通过铁砧附魔
        return false;
    }

    // ==============================
    // 客户端显示方法
    // ==============================

    /**
     * 添加物品悬停文本提示
     * <p>
     * 重写父类方法，在物品悬停时显示相关信息。
     * 调用TooltipUtils工具类添加通用的提示信息。
     * </p>
     *
     * @param stack   物品栈
     * @param level   世界对象
     * @param tooltip 提示文本列表
     * @param flag    提示标志
     */
    @Override
    @OnlyIn(Dist.CLIENT)
    public void appendHoverText(@NotNull ItemStack stack, @Nullable Level level, @NotNull List<Component> tooltip, @NotNull TooltipFlag flag) {
        int energyStored = getEnergyStored(stack);
        int displayMaxReceive = this.currentMaxReceive;
        if (stack.hasTag() && stack.getTag() != null) {
            if (stack.getTag().contains("MaxReceive")) {
                displayMaxReceive = stack.getTag().getInt("MaxReceive");
            }
        }

        // 等级描述
        TooltipUtils.addEnergyStorageLevel(tooltip, this.getDescriptionId(), tierNameKey);

        // 隔一行
        TooltipUtils.addSeparatorLine(tooltip);

        // 显示当前存储信息
        TooltipUtils.addEnergyStorageInfo(tooltip, this.getDescriptionId(), energyStored, capacity, displayMaxReceive);

        // 隔一行
        TooltipUtils.addSeparatorLine(tooltip);

        // 根据是否按下Shift键显示详细信息
        if (TooltipUtils.isShiftPressed()) {
            // 对于创造模式起子的特殊处理
            if (this instanceof CreativeScrewdriverItem) {
                TooltipUtils.addCreativeScrewdriverInfo(tooltip);
            } else {
                // 显示剩余槽位信息
                ToolModuleContainer container = createModuleContainer(stack);
                container.loadFromItemStack(stack);
                int usedSlots = container.getModuleCount();
                int maxSlots = container.getMaxModules();
                int remainingSlots = maxSlots - usedSlots;
                TooltipUtils.addRemainingSlotsInfo(tooltip, remainingSlots, maxSlots);
            }

            // 显示模块信息
            addModuleTooltip(stack, level, tooltip, flag);

            // 隔一行
            TooltipUtils.addSeparatorLine(tooltip);

            // 显示详细信息
            TooltipUtils.addDetailedInfo(tooltip, this.getDescriptionId());

            // 隔一行
            TooltipUtils.addSeparatorLine(tooltip);

            // 显示SHIFT+右键安装模块提示
            TooltipUtils.addModuleInstallPrompt(tooltip);

            // 显示CTRL+右键切换功能模块提示
            TooltipUtils.addFunctionModuleSwitchPrompt(tooltip);
        } else {
            // 提示按Shift查看详细信息
            TooltipUtils.addShiftPrompt(tooltip);

            // 显示SHIFT+右键安装模块提示
            TooltipUtils.addModuleInstallPrompt(tooltip);

            // 显示CTRL+右键切换功能模块提示
            TooltipUtils.addFunctionModuleSwitchPrompt(tooltip);
        }
    }
    
    /**
     * 添加模块提示信息
     * <p>
     * 当玩家按住Shift键时显示已安装的模块信息
     * </p>
     *
     * @param stack   物品栈
     * @param level   世界对象
     * @param tooltip 提示文本列表
     * @param flag    提示标志
     */
    public void addModuleTooltip(@NotNull ItemStack stack, @Nullable Level level, @NotNull List<Component> tooltip, @NotNull TooltipFlag flag) {
        // 与现有的按Shift显示功能整合
        if (Screen.hasShiftDown()) {
            ToolModuleContainer container = createModuleContainer(stack);
            container.loadFromItemStack(stack);
            displayInstalledModules(container, tooltip);
        }
    }

    /**
     * 显示已安装的模块信息
     * <p>
     * 显示所有已安装模块的名称和等级颜色
     * </p>
     *
     * @param container 模块容器
     * @param tooltip   提示文本列表
     */
    public void displayInstalledModules(ToolModuleContainer container, List<Component> tooltip) {
        if (!container.getModules().isEmpty()) {
            TooltipUtils.addInstalledModulesTitle(tooltip);
            addModuleListToTooltip(container, tooltip);
            
            // 显示当前激活的功能模块
            Optional<IModule> activeFunctionModule = container.getActiveFunctionModule();
            activeFunctionModule.ifPresent(
                    iModule -> TooltipUtils.addActiveFunctionModule(tooltip, iModule.getDisplayName())
            );
        } else {
            TooltipUtils.addNoModulesInstalled(tooltip);
        }
    }
    
    /**
     * 将模块列表添加到提示信息中
     * <p>
     * 遍历所有已安装的模块，并将它们添加到提示信息中
     * </p>
     *
     * @param container 模块容器
     * @param tooltip   提示文本列表
     */
    private void addModuleListToTooltip(ToolModuleContainer container, List<Component> tooltip) {
        for (IModule module : container.getModules()) {
            // 获取模块显示颜色
            ChatFormatting color = getModuleDisplayColor(module);
            tooltip.add(Component.literal("  ").append(module.getDisplayName()).withStyle(color));
        }
    }
    
    /**
     * 获取模块显示颜色
     * <p>
     * 根据模块类型和等级获取在提示信息中显示的颜色
     * </p>
     *
     * @param module 模块
     * @return 显示颜色
     */
    private ChatFormatting getModuleDisplayColor(IModule module) {
        // 根据模块等级设置不同的颜色
        ChatFormatting color = ChatFormatting.GRAY; // 默认颜色
        if (module instanceof ScrewdriverModuleItem screwdriverModule) {
            ScrewdriverModuleItem.ModuleLevel levelEnum = screwdriverModule.getModuleLevel();
            color = getModuleColor(levelEnum);
        }
        return color;
    }

    /**
     * 根据模块等级获取对应的颜色
     * <p>
     * 不同等级的模块使用不同颜色显示
     * </p>
     *
     * @param levelEnum 模块等级
     * @return 对应的颜色
     */
    private ChatFormatting getModuleColor(ScrewdriverModuleItem.ModuleLevel levelEnum) {
        return switch (levelEnum) {
            case BASIC -> ChatFormatting.GREEN; // 基础等级绿色
            case ADVANCED -> ChatFormatting.BLUE; // 中级等级蓝色
            case ELITE -> ChatFormatting.LIGHT_PURPLE; // 高级等级紫色
        };
    }

    // ==============================
    // 模块交互方法
    // ==============================

    /**
     * 右键使用物品
     *
     * @param level 世界
     * @param player 玩家
     * @param hand 手部
     * @return 交互结果
     */
    @Override
    public @NotNull InteractionResultHolder<ItemStack> use(@NotNull Level level, Player player, @NotNull InteractionHand hand) {
        ItemStack stack = player.getItemInHand(hand);

        // 检查是否按住Shift键
        if (player.isShiftKeyDown()) {
            // 主手持有起子时安装模块
            if (hand == InteractionHand.MAIN_HAND) {
                return handleModuleInstallation(level, player, hand, stack);
            }
            // 副手持有起子时取出模块
            else if (hand == InteractionHand.OFF_HAND) {
                return handleModuleRemoval(level, player, hand, stack);
            }
        } else if (Screen.hasControlDown()) {
            // 按住Ctrl键时切换功能模块（不需要点击方块）
            return handleFunctionModuleSwitch(level, player, stack);
        }

        return new InteractionResultHolder<>(InteractionResult.PASS, stack);
    }

    /**
     * 处理功能模块切换
     * <p>
     * 在按住Ctrl键的情况下使用起子，切换功能模块
     * </p>
     *
     * @param level  世界
     * @param player 玩家
     * @param stack  起子物品栈
     * @return 交互结果
     */
    private @NotNull InteractionResultHolder<ItemStack> handleFunctionModuleSwitch(@NotNull Level level, Player player, ItemStack stack) {
        ToolModuleContainer container = createModuleContainer(stack);
        container.loadFromItemStack(stack);
        
        // 获取所有功能模块
        List<IModule> functionModules = container.getModulesByCategory(ModuleCategory.FUNCTION);
        
        // 如果没有功能模块或只有一个功能模块，不需要切换
        if (functionModules.size() <= 1) {
            return new InteractionResultHolder<>(InteractionResult.PASS, stack);
        }
        
        // 获取当前激活的功能模块
        Optional<IModule> currentActive = container.getActiveFunctionModule();
        
        // 找到下一个功能模块
        IModule nextModule = getNextFunctionModule(functionModules, currentActive.orElse(null));
        
        // 设置新的激活模块
        if (nextModule != null) {
            container.setActiveFunctionModule(nextModule.getModuleId());
            container.saveToItemStack(stack);
            
            // 在客户端显示切换信息
            if (level.isClientSide) {
                player.displayClientMessage(
                    Component.translatable("message.timetale_re.function_module_switched", nextModule.getDisplayName()), 
                    true);
            }
            
            return new InteractionResultHolder<>(InteractionResult.SUCCESS, stack);
        }
        
        return new InteractionResultHolder<>(InteractionResult.PASS, stack);
    }
    
    /**
     * 获取下一个功能模块
     * <p>
     * 在功能模块列表中找到当前模块的下一个模块
     * </p>
     *
     * @param functionModules 功能模块列表
     * @param currentActive   当前激活的模块
     * @return 下一个功能模块
     */
    private IModule getNextFunctionModule(List<IModule> functionModules, IModule currentActive) {
        if (functionModules.isEmpty()) {
            return null;
        }
        
        // 如果当前没有激活的模块，返回第一个
        if (currentActive == null) {
            return functionModules.get(0);
        }
        
        // 找到当前模块的索引
        int currentIndex = -1;
        for (int i = 0; i < functionModules.size(); i++) {
            if (functionModules.get(i).getModuleId().equals(currentActive.getModuleId())) {
                currentIndex = i;
                break;
            }
        }
        
        // 如果没找到当前模块，返回第一个
        if (currentIndex == -1) {
            return functionModules.get(0);
        }
        
        // 返回下一个模块（循环）
        int nextIndex = (currentIndex + 1) % functionModules.size();
        return functionModules.get(nextIndex);
    }

    /**
     * 处理模块安装逻辑
     * <p>
     * 当玩家按住Shift键并使用起子时，检查副手是否持有模块物品并尝试安装
     * </p>
     *
     * @param level  世界
     * @param player 玩家
     * @param hand   手部
     * @param stack  起子物品栈
     * @return 交互结果
     */
    private @NotNull InteractionResultHolder<ItemStack> handleModuleInstallation(@NotNull Level level, Player player, @NotNull InteractionHand hand, ItemStack stack) {
        // 检查主手是否持有起子（确保是主手操作）
        if (hand != InteractionHand.MAIN_HAND) {
            return new InteractionResultHolder<>(InteractionResult.PASS, stack);
        }
        
        return processModuleInstallation(level, player, stack);
    }
    
    /**
     * 处理模块安装过程
     * <p>
     * 检查副手是否持有模块物品，如果是则尝试安装到起子上
     * </p>
     *
     * @param level  世界
     * @param player 玩家
     * @param stack  起子物品栈
     * @return 交互结果
     */
    private @NotNull InteractionResultHolder<ItemStack> processModuleInstallation(@NotNull Level level, Player player, ItemStack stack) {
        // 获取副手物品（模块）
        ItemStack otherStack = player.getItemInHand(InteractionHand.OFF_HAND);

        // 检查副手是否持有模块物品
        if (otherStack.getItem() instanceof ScrewdriverModuleItem moduleItem) {
            // 检查是否为创造等级起子
            if (stack.getItem() instanceof CreativeScrewdriverItem) {
                handleCreativeScrewdriverInstallDeny(level, player);
                return new InteractionResultHolder<>(InteractionResult.PASS, stack);
            }
            
            return installModule(level, player, stack, otherStack, moduleItem);
        }

        return new InteractionResultHolder<>(InteractionResult.PASS, stack);
    }
    
    /**
     * 处理创造模式起子安装模块被拒绝的情况
     * <p>
     * 向玩家显示创造模式起子无法安装模块的提示信息
     * </p>
     *
     * @param level  世界
     * @param player 玩家
     */
    private void handleCreativeScrewdriverInstallDeny(@NotNull Level level, Player player) {
        if (level.isClientSide) {
            player.displayClientMessage(Component.translatable("message.timetale_re.creative_screwdriver_module_install_denied"), true);
        }
    }
    
    /**
     * 处理模块取出逻辑
     * <p>
     * 当玩家副手持有起子时，按下Shift键可以取出模块，无论主手是否为空
     * </p>
     *
     * @param level  世界
     * @param player 玩家
     * @param hand   手部
     * @param stack  起子物品栈
     * @return 交互结果
     */
    private @NotNull InteractionResultHolder<ItemStack> handleModuleRemoval(@NotNull Level level, Player player, @NotNull InteractionHand hand, ItemStack stack) {
        // 检查副手是否持有起子（确保是副手操作）
        if (hand != InteractionHand.OFF_HAND) {
            return new InteractionResultHolder<>(InteractionResult.PASS, stack);
        }

        return processModuleRemoval(level, player, hand, stack);
    }
    
    /**
     * 处理模块移除过程
     * <p>
     * 检查起子中是否还有模块可以移除，并根据情况执行移除操作或打开选择界面
     * </p>
     *
     * @param level  世界
     * @param player 玩家
     * @param hand   手部
     * @param stack  起子物品栈
     * @return 交互结果
     */
    private @NotNull InteractionResultHolder<ItemStack> processModuleRemoval(@NotNull Level level, Player player, @NotNull InteractionHand hand, ItemStack stack) {
        // 创建模块容器并加载现有模块
        ToolModuleContainer container = createModuleContainer(stack);
        container.loadFromItemStack(stack);

        // 检查是否还有模块可以移除
        if (container.getModuleCount() > 0) {
            // 检查是否为创造等级起子
            if (stack.getItem() instanceof CreativeScrewdriverItem) {
                handleCreativeScrewdriverRemoveDeny(level, player);
                return new InteractionResultHolder<>(InteractionResult.PASS, stack);
            }
            
            return handleModuleRemovalByCount(level, player, hand, stack, container);
        }

        // 没有模块可以移除
        handleNoModulesToRemove(level, player);
        return new InteractionResultHolder<>(InteractionResult.PASS, stack);
    }
    
    /**
     * 处理创造模式起子移除模块被拒绝的情况
     * <p>
     * 向玩家显示创造模式起子无法移除模块的提示信息
     * </p>
     *
     * @param level  世界
     * @param player 玩家
     */
    private void handleCreativeScrewdriverRemoveDeny(@NotNull Level level, Player player) {
        if (level.isClientSide) {
            player.displayClientMessage(Component.translatable("message.timetale_re.creative_screwdriver_module_remove_denied"), true);
        }
    }
    
    /**
     * 根据模块数量处理模块移除
     * <p>
     * 如果只有一个模块则直接移除，如果有多个模块则打开选择界面
     * </p>
     *
     * @param level     世界
     * @param player    玩家
     * @param hand      手部
     * @param stack     起子物品栈
     * @param container 模块容器
     * @return 交互结果
     */
    private @NotNull InteractionResultHolder<ItemStack> handleModuleRemovalByCount(@NotNull Level level, Player player, @NotNull InteractionHand hand, ItemStack stack, ToolModuleContainer container) {
        // 如果只有一个模块，直接移除
        if (container.getModuleCount() == 1) {
            return removeModule(level, player, stack);
        } else {
            // 如果有多个模块，在客户端打开选择界面
            openModuleSelectionScreen(level, player, hand, stack);
            return new InteractionResultHolder<>(InteractionResult.SUCCESS, stack);
        }
    }
    
    /**
     * 打开模块选择界面
     * <p>
     * 在客户端打开模块选择界面，允许玩家选择要移除的模块
     * </p>
     *
     * @param level  世界
     * @param player 玩家
     * @param hand   手部
     * @param stack  起子物品栈
     */
    private void openModuleSelectionScreen(@NotNull Level level, Player player, @NotNull InteractionHand hand, ItemStack stack) {
        if (level.isClientSide) {
            Minecraft.getInstance().setScreen(new ModuleSelectionScreen(stack, this, () -> {
                // 重新设置玩家手中的物品
                player.setItemInHand(hand, stack);
            }));
        }
    }
    
    /**
     * 处理没有模块可移除的情况
     * <p>
     * 向玩家显示没有模块可移除的提示信息
     * </p>
     *
     * @param level  世界
     * @param player 玩家
     */
    private void handleNoModulesToRemove(@NotNull Level level, Player player) {
        if (level.isClientSide) {
            player.displayClientMessage(Component.translatable("message.timetale_re.no_modules_to_remove"), true);
        }
    }

    /**
     * 安装模块
     * <p>
     * 尝试将模块物品安装到起子上
     * </p>
     *
     * @param level       世界
     * @param player      玩家
     * @param stack       起子物品栈
     * @param otherStack  模块物品栈
     * @param moduleItem  模块物品
     * @return 交互结果
     */
    private @NotNull InteractionResultHolder<ItemStack> installModule(@NotNull Level level, Player player, ItemStack stack, ItemStack otherStack, ScrewdriverModuleItem moduleItem) {
        // 检查模块物品是否有效
        if (!(otherStack.getItem() instanceof ScrewdriverModuleItem)) {
            return new InteractionResultHolder<>(InteractionResult.PASS, stack);
        }
        
        // 创建模块容器并加载现有模块
        ToolModuleContainer container = createModuleContainer(stack);
        container.loadFromItemStack(stack);

        // 检查是否还能添加更多模块
        if (!container.isFull()) {
            return tryToAddModule(level, player, stack, otherStack, moduleItem, container);
        }

        return new InteractionResultHolder<>(InteractionResult.PASS, stack);
    }
    
    /**
     * 尝试添加模块到起子
     * <p>
     * 检查模块是否可以安装，如果可以则添加到起子中
     * </p>
     *
     * @param level       世界
     * @param player      玩家
     * @param stack       起子物品栈
     * @param otherStack  模块物品栈
     * @param moduleItem  模块物品
     * @param container   模块容器
     * @return 交互结果
     */
    private @NotNull InteractionResultHolder<ItemStack> tryToAddModule(@NotNull Level level, Player player, ItemStack stack, ItemStack otherStack, ScrewdriverModuleItem moduleItem, ToolModuleContainer container) {
        // 获取模块ID - 从物品中获取实际的模块ID
        String moduleId = moduleItem.getModuleId();
        
        // 检查模块ID是否有效
        if (moduleId == null || moduleId.isEmpty()) {
            return new InteractionResultHolder<>(InteractionResult.PASS, stack);
        }

        return processModuleAddition(level, player, stack, otherStack, moduleItem, container, moduleId);
    }
    
    /**
     * 处理模块添加过程
     * <p>
     * 尝试获取模块并检查是否可以安装到起子上
     * </p>
     *
     * @param level       世界
     * @param player      玩家
     * @param stack       起子物品栈
     * @param otherStack  模块物品栈
     * @param moduleItem  模块物品
     * @param container   模块容器
     * @param moduleId    模块ID
     * @return 交互结果
     */
    private @NotNull InteractionResultHolder<ItemStack> processModuleAddition(@NotNull Level level, Player player, ItemStack stack, ItemStack otherStack, ScrewdriverModuleItem moduleItem, ToolModuleContainer container, String moduleId) {
        // 尝试添加模块
        Optional<IModule> moduleOpt = Modules.getModule(moduleId);
        if (moduleOpt.isPresent()) {
            IModule module = moduleOpt.get();
            // 检查起子等级是否允许安装该模块
            if (canInstallModule(stack, moduleItem)) {
                return addModuleToScrewdriver(level, player, stack, otherStack, container, module);
            } else {
                return handleModuleInstallRestriction(level, player);
            }
        }
        
        return new InteractionResultHolder<>(InteractionResult.PASS, stack);
    }
    
    /**
     * 将模块添加到起子中
     * <p>
     * 实际执行模块添加操作
     * </p>
     *
     * @param level      世界
     * @param player     玩家
     * @param stack      起子物品栈
     * @param otherStack 模块物品栈
     * @param container  模块容器
     * @param module     模块
     * @return 交互结果
     */
    private @NotNull InteractionResultHolder<ItemStack> addModuleToScrewdriver(@NotNull Level level, Player player, ItemStack stack, ItemStack otherStack, ToolModuleContainer container, IModule module) {
        if (container.addModule(module)) {
            return handleSuccessfulInstallation(level, player, stack, otherStack, container, module);
        } else {
            return handleFailedInstallation(level, player, container, module);
        }
    }
    
    /**
     * 处理模块安装成功的情况
     * <p>
     * 保存模块到起子，消耗模块物品，并向玩家显示成功信息
     * </p>
     *
     * @param level      世界
     * @param player     玩家
     * @param stack      起子物品栈
     * @param otherStack 模块物品栈
     * @param container  模块容器
     * @param module     模块
     * @return 交互结果
     */
    private @NotNull InteractionResultHolder<ItemStack> handleSuccessfulInstallation(@NotNull Level level, Player player, ItemStack stack, ItemStack otherStack, ToolModuleContainer container, IModule module) {
        // 保存模块到起子
        container.saveToItemStack(stack);

        // 消耗副手的模块物品（即使是创造模式也消耗）
        otherStack.shrink(1);

        // 显示安装成功信息（需要在客户端实现）
        if (level.isClientSide) {
            player.displayClientMessage(Component.translatable("message.timetale_re.module_installed", module.getDisplayName()), true);
        }

        return new InteractionResultHolder<>(InteractionResult.SUCCESS, stack);
    }

    /**
     * 处理模块安装失败的情况
     * <p>
     * 当模块无法安装时（如类型冲突），向玩家显示失败信息
     * </p>
     *
     * @param level     世界
     * @param player    玩家
     * @param container 模块容器
     * @param module    模块
     * @return 交互结果
     */
    private @NotNull InteractionResultHolder<ItemStack> handleFailedInstallation(@NotNull Level level, Player player, ToolModuleContainer container, IModule module) {
        // 显示安装失败信息（模块类型已存在）
        if (level.isClientSide) {
            ModuleType moduleType = module.getModuleType();
            if (moduleType != null && container.hasModuleOfType(moduleType)) {
                player.displayClientMessage(Component.translatable("message.timetale_re.module_type_already_installed", moduleType.getTypeName()), true);
            } else if (module.getModuleCategory() == ModuleCategory.FUNCTION) {
                // 功能模块安装失败，因为已经有其他功能模块
                player.displayClientMessage(Component.translatable("message.timetale_re.function_module_already_installed"), true);
            }
        }

        return new InteractionResultHolder<>(InteractionResult.PASS, player.getItemInHand(InteractionHand.MAIN_HAND));
    }
    
    /**
     * 处理模块安装限制情况
     * <p>
     * 当模块因等级限制无法安装时的处理逻辑
     * </p>
     *
     * @param level  世界
     * @param player 玩家
     * @return 交互结果
     */
    private @NotNull InteractionResultHolder<ItemStack> handleModuleInstallRestriction(@NotNull Level level, Player player) {
        // 显示安装限制信息
        if (level.isClientSide) {
            player.displayClientMessage(Component.translatable("message.timetale_re.module_install_restricted"), true);
        }
        return new InteractionResultHolder<>(InteractionResult.PASS, player.getItemInHand(InteractionHand.MAIN_HAND));
    }

    /**
     * 移除模块
     * <p>
     * 从起子中移除最新的模块并放到玩家物品栏或掉落在地上
     * </p>
     *
     * @param level  世界
     * @param player 玩家
     * @param stack  起子物品栈
     * @return 交互结果
     */
    private @NotNull InteractionResultHolder<ItemStack> removeModule(@NotNull Level level, Player player, ItemStack stack) {
        // 创建模块容器并加载现有模块
        ToolModuleContainer container = createModuleContainer(stack);
        container.loadFromItemStack(stack);

        // 检查是否还有模块可以移除
        if (container.getModuleCount() > 0) {
            // 获取最后一个安装的模块（后进先出）
            IModule module = container.getModules().get(container.getModules().size() - 1);
            
            // 尝试移除模块
            Optional<IModule> removedModuleOpt = container.removeModule(module.getModuleId());
            return removedModuleOpt.map(iModule -> handleSuccessfulRemoval(level, player, stack, container, iModule))
                    .orElseGet(() -> handleFailedRemoval(level, player, container, module));
        }

        // 没有模块可以移除
        if (level.isClientSide) {
            player.displayClientMessage(Component.translatable("message.timetale_re.no_modules_to_remove"), true);
        }
        return new InteractionResultHolder<>(InteractionResult.PASS, stack);
    }

    /**
     * 处理模块移除成功的情况
     * <p>
     * 保存起子状态，将模块放到玩家物品栏或掉落在地上，并向玩家显示成功信息
     * </p>
     *
     * @param level     世界
     * @param player    玩家
     * @param stack     起子物品栈
     * @param container 模块容器
     * @param module    被移除的模块
     * @return 交互结果
     */
    private @NotNull InteractionResultHolder<ItemStack> handleSuccessfulRemoval(@NotNull Level level, Player player, ItemStack stack, ToolModuleContainer container, IModule module) {
        // 保存起子状态
        container.saveToItemStack(stack);

        // 将模块放到玩家物品栏或掉落在地上
        ScrewdriverModuleUtils.handleModuleRemoval(player, module);

        // 显示移除成功信息（需要在客户端实现）
        if (level.isClientSide) {
            player.displayClientMessage(Component.translatable("message.timetale_re.module_removed", module.getDisplayName()), true);
        }

        return new InteractionResultHolder<>(InteractionResult.SUCCESS, stack);
    }

    /**
     * 处理模块移除失败的情况
     * <p>
     * 当模块无法移除时，向玩家显示失败信息
     * </p>
     *
     * @param level     世界
     * @param player    玩家
     * @param container 模块容器
     * @param module    模块
     * @return 交互结果
     */
    private @NotNull InteractionResultHolder<ItemStack> handleFailedRemoval(@NotNull Level level, Player player, ToolModuleContainer container, IModule module) {
        // 显示移除失败信息
        if (level.isClientSide) {
            player.displayClientMessage(Component.translatable("message.timetale_re.module_remove_failed", module.getDisplayName()), true);
        }

        return new InteractionResultHolder<>(InteractionResult.PASS, player.getItemInHand(InteractionHand.OFF_HAND));
    }

    /**
     * 右键方块
     *
     * @param context 使用上下文
     * @return 交互结果
     */
    @Override
    public @NotNull InteractionResult useOn(@NotNull UseOnContext context) {
        // 检查是否安装了红石模块（使用激活的功能模块）
        ItemStack stack = context.getItemInHand();
        ToolModuleContainer container = createModuleContainer(stack);
        container.loadFromItemStack(stack);
        
        if (hasActiveRedstoneModule(container)) {
            // 触发红石模块功能
            return triggerRedstoneModule(context, container);
        }
        
        // 检查是否安装了朝向模块（使用激活的功能模块）
        if (hasActiveRotationModule(container)) {
            // 触发朝向模块功能
            return triggerRotationModule(context, container);
        }
        return InteractionResult.PASS;
    }

    /**
     * 检查是否有激活的红石模块
     * <p>
     * 检查已安装的模块中是否有激活的红石模块
     * </p>
     *
     * @param container 模块容器
     * @return 是否有激活的红石模块
     */
    private boolean hasActiveRedstoneModule(ToolModuleContainer container) {
        Optional<IModule> activeModule = container.getActiveFunctionModule();
        return activeModule.isPresent() && activeModule.get().getModuleType() == ModuleType.REDSTONE;
    }
    
    /**
     * 检查是否有激活的朝向模块
     * <p>
     * 检查已安装的模块中是否有激活的朝向模块
     * </p>
     *
     * @param container 模块容器
     * @return 是否有激活的朝向模块
     */
    private boolean hasActiveRotationModule(ToolModuleContainer container) {
        Optional<IModule> activeModule = container.getActiveFunctionModule();
        return activeModule.isPresent() && activeModule.get().getModuleType() == ModuleType.ROTATION;
    }
    
    /**
     * 触发红石模块功能
     * <p>
     * 执行红石模块的功能逻辑
     * </p>
     *
     * @param context 使用上下文
     * @param container 模块容器
     * @return 交互结果
     */
    private InteractionResult triggerRedstoneModule(UseOnContext context, ToolModuleContainer container) {
        // 查找激活的红石模块
        return container.getActiveFunctionModule()
                .filter(module -> module instanceof RedstoneModuleItem)
                .map(module -> (RedstoneModuleItem) module)
                .map(redstoneModule -> redstoneModule.activateRedstoneSignal(context))
                .orElse(InteractionResult.PASS);
    }
    
    /**
     * 触发朝向模块功能
     * <p>
     * 执行朝向模块的功能逻辑，旋转方块
     * </p>
     *
     * @param context 使用上下文
     * @param container 模块容器
     * @return 交互结果
     */
    private InteractionResult triggerRotationModule(UseOnContext context, ToolModuleContainer container) {
        // 查找激活的朝向模块
        return container.getActiveFunctionModule()
                .filter(module -> module instanceof RotationModuleItem)
                .map(module -> (RotationModuleItem) module)
                .map(rotationModule -> rotationModule.rotateBlock(context))
                .orElse(InteractionResult.PASS);
    }

    // ==============================
    // 挖掘功能方法
    // ==============================

    @Override
    public boolean isCorrectToolForDrops(ItemStack stack, BlockState state) {
        ToolModuleContainer container = createModuleContainer(stack);
        container.loadFromItemStack(stack);

        // 检查是否安装了挖掘模块
        return hasSuitableMiningModule(container, state);
    }

    /**
     * 检查是否有合适地挖掘模块
     * <p>
     * 检查已安装的模块中是否有能够挖掘指定方块的挖掘模块
     * </p>
     *
     * @param container 模块容器
     * @param state     方块状态
     * @return 是否有合适的挖掘模块
     */
    private boolean hasSuitableMiningModule(ToolModuleContainer container, BlockState state) {
        return container.getModules().stream()
                .filter(module -> module instanceof MiningModule)
                .anyMatch(module -> isModuleSuitableForBlock((MiningModule) module, state));
    }
    
    /**
     * 检查挖掘模块是否适合挖掘指定方块
     * <p>
     * 检查挖掘模块是否可以挖掘指定方块
     * </p>
     *
     * @param miningModule 挖掘模块
     * @param state        方块状态
     * @return 挖掘模块是否适合挖掘该方块
     */
    private boolean isModuleSuitableForBlock(MiningModule miningModule, BlockState state) {
        // 使用模块提供的检查方法
        return checkModuleHarvestCapability(miningModule, state) &&
                checkModuleTierSuitability(miningModule, state);
    }
    
    /**
     * 检查挖掘模块是否可以收获指定方块
     * <p>
     * 使用模块自身的检查方法判断是否可以收获方块
     * </p>
     *
     * @param miningModule 挖掘模块
     * @param state        方块状态
     * @return 模块是否可以收获该方块
     */
    private boolean checkModuleHarvestCapability(MiningModule miningModule, BlockState state) {
        return miningModule.canHarvest(state);
    }
    
    /**
     * 检查挖掘模块等级是否适合挖掘指定方块
     * <p>
     * 使用TierSortingRegistry检查模块等级是否适合挖掘方块
     * </p>
     *
     * @param miningModule 挖掘模块
     * @param state        方块状态
     * @return 模块等级是否适合挖掘该方块
     */
    private boolean checkModuleTierSuitability(MiningModule miningModule, BlockState state) {
        return TierSortingRegistry.isCorrectTierForDrops(
                miningModule.getTier(), state);
    }

    @Override
    public float getDestroySpeed(@NotNull ItemStack stack, @NotNull BlockState state) {
        ToolModuleContainer container = createModuleContainer(stack);
        container.loadFromItemStack(stack);

        // 检查是否安装了挖掘模块
        return getMiningSpeed(container, state);
    }

    /**
     * 获取挖掘速度
     * <p>
     * 根据已安装的挖掘模块获取对指定方块的挖掘速度
     * </p>
     *
     * @param container 模块容器
     * @param state     方块状态
     * @return 挖掘速度
     */
    private float getMiningSpeed(ToolModuleContainer container, BlockState state) {
        return container.getModules().stream()
                .filter(module -> module instanceof MiningModule)
                .findFirst()
                .map(module -> calculateDestroySpeed((MiningModule) module, state))
                .orElse(1.0f);
    }
    
    /**
     * 计算挖掘模块对方块的挖掘速度
     * <p>
     * 根据挖掘模块和方块状态计算挖掘速度
     * </p>
     *
     * @param miningModule 挖掘模块
     * @param state        方块状态
     * @return 挖掘速度
     */
    private float calculateDestroySpeed(MiningModule miningModule, BlockState state) {
        return miningModule.getDestroySpeed(state);
    }

    // ==============================
    // 攻击属性方法
    // ==============================

    @Override
    public Multimap<Attribute, AttributeModifier> getAttributeModifiers(EquipmentSlot slot, ItemStack stack) {
        // 获取父类的属性修饰符
        Multimap<Attribute, AttributeModifier> modifiers = super.getAttributeModifiers(slot, stack);

        // 只在主手时应用攻击伤害
        if (slot == EquipmentSlot.MAINHAND) {
            return addAttackDamageModifier(stack, modifiers);
        }

        // 如果没有攻击模块，返回原始修饰符
        return modifiers;
    }

    /**
     * 添加攻击伤害修饰符
     * <p>
     * 根据已安装的攻击模块添加对应的攻击伤害属性修饰符
     * </p>
     *
     * @param stack     物品栈
     * @param modifiers 原始属性修饰符
     * @return 添加了攻击伤害修饰符的属性修饰符
     */
    private Multimap<Attribute, AttributeModifier> addAttackDamageModifier(ItemStack stack, Multimap<Attribute, AttributeModifier> modifiers) {
        ToolModuleContainer container = createModuleContainer(stack);
        container.loadFromItemStack(stack);

        // 查找攻击模块
        Optional<AttackModule> attackModuleOpt = getAttackModule(container);

        // 如果找到攻击模块，创建新的可变Multimap
        return attackModuleOpt.map(attackModule -> buildModifiedAttributes(modifiers, attackModule))
                .orElse(modifiers);
    }

    /**
     * 从模块容器中获取攻击模块
     * <p>
     * 查找已安装模块中的第一个攻击模块
     * </p>
     *
     * @param container 模块容器
     * @return 攻击模块的Optional
     */
    private Optional<AttackModule> getAttackModule(ToolModuleContainer container) {
        return container.getModules().stream()
                .filter(module -> module instanceof AttackModule)
                .map(module -> (AttackModule) module)
                .findFirst();
    }

    /**
     * 构建修改后的属性
     * <p>
     * 创建包含攻击伤害修饰符的新属性集合
     * </p>
     *
     * @param modifiers    原始属性修饰符
     * @param attackModule 攻击模块
     * @return 修改后的属性修饰符
     */
    private Multimap<Attribute, AttributeModifier> buildModifiedAttributes(Multimap<Attribute, AttributeModifier> modifiers, AttackModule attackModule) {
        // 创建一个新的可变Multimap
        ImmutableMultimap.Builder<Attribute, AttributeModifier> builder = ImmutableMultimap.builder();
        // 复制现有的所有修饰符
        copyExistingModifiers(builder, modifiers);
        // 添加攻击伤害修饰符
        addAttackDamageModifier(builder, attackModule);
        // 返回新的不可变Multimap
        return builder.build();
    }
    
    /**
     * 复制现有的属性修饰符
     * <p>
     * 将原始的属性修饰符复制到新的构建器中
     * </p>
     *
     * @param builder    属性修饰符构建器
     * @param modifiers  原始属性修饰符
     */
    private void copyExistingModifiers(ImmutableMultimap.Builder<Attribute, AttributeModifier> builder, Multimap<Attribute, AttributeModifier> modifiers) {
        builder.putAll(modifiers);
    }
    
    /**
     * 添加攻击伤害属性修饰符
     * <p>
     * 根据攻击模块的攻击伤害值添加对应的属性修饰符
     * </p>
     *
     * @param builder       属性修饰符构建器
     * @param attackModule  攻击模块
     */
    private void addAttackDamageModifier(ImmutableMultimap.Builder<Attribute, AttributeModifier> builder, AttackModule attackModule) {
        builder.put(Attributes.ATTACK_DAMAGE, new AttributeModifier(
                ATTACK_DAMAGE_MODIFIER,
                "Module attack damage",
                attackModule.getAttackDamage(),
                AttributeModifier.Operation.ADDITION
        ));
    }
}